#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <set>
using namespace std;
#define int long long
#define pii pair<int, int>
#define INF 998244353
#define N 200009


vector<int> e[N];
int fa[N], a[N], c[N], f[800009], g[800009];
int d[N], b[N], mi[N], ma[N];
int n, m, t, w, tot, op, x, y;

int ab(int x) {
	return x > 0 ? x : -x;
}

int gcd(int x, int y) {
	x = ab(x);
	y = ab(y);
	if (x == 0)return y;
	if (y == 0)return x;
	return y ? gcd(y, x % y) : x;
}

void down(int p) {
	if (f[p]) {
		f[2 * p] += f[p];
		f[2 * p + 1] += f[p];
		f[p] = 0;
	}
}

void ins(int jl, int jr, int jv, int l, int r, int p) {
	if (jl <= l && r <= jr) {
		f[p] += jv;
		return;
	}
	down(p);
	int m = (l + r) >> 1;
	if (jl <= m)ins(jl, jr, jv, l, m, 2 * p);
	if (jr > m)ins(jl, jr, jv, m + 1, r, 2 * p + 1);
}

int get(int index, int l, int r, int p) {
	if (l == r && l == index) {
		return f[p];
	}
	down(p);
	int m = (l + r) >> 1;
	if (index <= m)return get(index, l, m, 2 * p);
	else return get(index, m + 1, r, 2 * p + 1);
}

void change(int index, int v, int l, int r, int p) {

	if (l == r ) {
		g[p] += v;
		return;
	}
	int m = (l + r) >> 1;
	if (index <= m)change(index, v, l, m, 2 * p);
	else change(index, v, m + 1, r, 2 * p + 1);
	g[p] = gcd(g[2 * p], g[2 * p + 1]);
}

int find(int jl, int jr, int l, int r, int p) {
	if (jl == l && r == jr) {
		return g[p];
	}
	int m = (l + r) >> 1;
	if (jr <= m)return find(jl, jr, l, m, 2 * p);
	else if (m < jl)return find(jl, jr, m + 1, r, 2 * p + 1);
	else return gcd(find(jl, m, l, m, 2 * p), find(m + 1, jr, m + 1, r, 2 * p + 1));
}

void up(int l, int r, int v) {
	ins(l, r, v, 1, n, 1);
	change(l, v, 1, n, 1);
	change(r + 1, -v, 1, n, 1);
}

void solve() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		mi[i] = INF;
		cin >> a[i];
	}
	for (int i = 1, u, v; i < n; i++) {
		cin >> u >> v;
		e[u].push_back(v);
		e[v].push_back(u);
	}
	t = 0; w = 1;
	d[1] = tot = 1;
	b[1] = 1;
	while (t < w) {
		int u = d[++t];
		for (int v : e[u]){
			if (fa[u] != v) {
				fa[v] = u;
				b[v] = ++tot;
				d[++w] = v;
			}
		}
	}
	for (int i = 1; i <= n; i++) {
		for (int j : e[i]) {
			if (fa[i] != j) {
				mi[i] = min(mi[i], b[j]);
				ma[i] = max(ma[i], b[j]);
			}
		}
	}
	for (int i = 1; i <= n; i++) {
		ins(b[i], b[i], a[i], 1, n, 1);
		d[b[i]] = a[i];
	}
	for (int i = 2; i <= n; i++) {
		c[i] = d[i] - d[i - 1];
		change(i, c[i], 1, n, 1);
	}
	while (m--) {
		cin >> op;

		if (op == 1) {
			cin >> x >> y;
			up(b[x], b[x], y);
			if (x != 1)up(b[fa[x]], b[fa[x]], y);
			if (ma[x])up(mi[x], ma[x], y);
		}
		else {
			cin >> x;
			int res = get(b[x], 1, n, 1);
			if (x != 1)res = gcd(res, get(b[fa[x]], 1, n, 1));
			if (ma[x]) {
				res = gcd(res, get(ma[x], 1, n, 1));
				if (ma[x] != mi[x])res = gcd(res, find(mi[x] + 1, ma[x], 1, n, 1));
			}
			cout << res << '\n';
		}
	}
}

signed main() {
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	solve();
	return 0;
}

//
//int ab(int x) {
//    return x > 0 ? x : -x;
//}
//
//int gcd(int x, int y) {
//    return y ? gcd(y, x % y) : x;
//}
//
//void down(int p) {
//    if (f[p]) {
//        f[2 * p] += f[p];
//        f[2 * p + 1] += f[p];
//        f[p] = 0;
//    }
//}
//
//void ins(int jl, int jr, int jv, int l, int r, int p) {
//    if (jl <= l && r <= jr) {
//        f[p] += jv;
//        return;
//    }
//    down(p);
//    int m = (l + r) >> 1;
//    if (jl <= m) ins(jl, jr, jv, l, m, 2 * p);
//    if (jr > m) ins(jl, jr, jv, m + 1, r, 2 * p + 1);
//}
//
//int get(int index, int l, int r, int p) {
//    if (l == r && l == index) {
//        return f[p];
//    }
//    down(p);
//    int m = (l + r) >> 1;
//    if (index <= m) return get(index, l, m, 2 * p);
//    else return get(index, m + 1, r, 2 * p + 1);
//}
//
//void change(int index, int v, int l, int r, int p) {
//    if (l == r && l == index) {
//        g[p] += v;
//        return;
//    }
//    int m = (l + r) >> 1;
//    if (index <= m)change(index, v, l, m, 2 * p);
//    if (index > m)change(index, v, m + 1, r, 2 * p + 1);
//    g[p] = gcd(g[2 * p], g[2 * p + 1]);
//}
//
//int find(int jl, int jr, int l, int r, int p) {
//    if (jl <= l && r <= jr) {
//        return g[p];
//    }
//    int m = (l + r) >> 1;
//    if (m >= jr)return find(jl, jr, l, m, 2 * p);
//    if (m < jl)return find(jl, jr, m + 1, r, 2 * p + 1);
//    return gcd(find(jl, m, l, m, 2 * p), find(m+1, jr, m + 1, r, 2 * p + 1));
//}
//
//void up(int jl, int jr, int jv) {
//    ins(jl, jr, jv, 1, n, 1);
//    change(jl, jv, 1, n, 1);
//    change(jr + 1, -jv, 1, n, 1);
//}
//
//
//signed main() {
//    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
//    cin >> n >> m;
//    for (int i = 1; i <= n; i++) {
//        cin >> a[i];
//        mi[i] = INF;
//    }
//    for (int i = 1, u, v; i < n; i++) {
//        cin >> u >> v;
//        e[u].push_back(v);
//        e[v].push_back(u);
//    }
//    t = 0, w = 1;
//    b[1] = tot = 1;
//    d[1] = 1;
//    while (t < w) {
//        int u = d[++t];
//        for (int i : e[u]) {
//            if (fa[u] != i) {
//                fa[i] = u;
//                b[i] = ++tot;
//                d[++w] = i;
//            }
//        }
//    }
//    for (int i = 1; i <= n; i++) {
//        for (int j : e[i]) {
//            if (fa[i] != j) {
//                mi[i] = min(mi[i], b[j]);
//                ma[i] = max(ma[i], b[j]);
//            }
//        }
//    }
//    for (int i = 1; i <= n; i++) {
//        ins(b[i], b[i], a[i], 1, n, 1);
//        d[b[i]] = a[i];
//    }
//    for (int i = 2; i <= n; i++) {
//        c[i] = d[i] - d[i - 1];
//        change(i, c[i], 1, n, 1);
//    }
//    while (m--) {
//        int op;
//        int x, y;
//        cin >> op;
//        if (op == 1) {
//			cin >> x >> y;
//            up(b[x], b[x], y);
//            if (x != 1) up(b[fa[x]], b[fa[x]], y);
//            if (ma[x]) up(mi[x], ma[x], y);
//        }
//        else {
//            cin >> x;
//            int ans = get(b[x],1,n,1);
//            if (x != 1) ans = gcd(ans, get(b[fa[x]], 1, n, 1));
//            if (ma[x]) {
//                ans = gcd(ans, get(ma[x], 1, n, 1));
//                if (ma[x] != mi[x]) ans = gcd(ans, find(mi[x], ma[x] - 1, 1, n, 1));
//            }
//            cout << ans << '\n';
//        }
//    }
//    return 0;
//}